#include <iostream>
#include <string>
#include <cassert>
#include <unistd.h>
#include <vector>
#include <sys/types.h>
#include <sys/wait.h>
#include "task.hpp"

using namespace std;

const int gnum = 3;
Task t; // 定义为全局的

// 用于存储子进程的pid和相对应管道的文件描述符
class EndPoint
{
    //计数器
    static int number;
public:
    EndPoint(pid_t child_id, int write_id)
        : _child_id(child_id), _write_id(write_id)
    {
        //进程名的格式：process-0[pid,fd]
        char namebuffer[64];
        snprintf(namebuffer,sizeof(namebuffer),"process-%d[%d:%d]",number++,_child_id,_write_id);
        processname=namebuffer;
    }

    std::string name() const
    {
        return processname;
    }

    ~EndPoint()
    {
    }

public:
    pid_t _child_id; // 子进程的pid
    int _write_id;   // 相对应管道的文件描述符
    std::string processname; //进程的名字 
};
int EndPoint::number=0;

// 子进程读数据
void WaitCommand()
{
    while(true)
    {
        int command;
        //一次读取4个字节
        int n = read(0, &command, sizeof(int));
        //成功读取4字节，就执行对应的命令
        if (n == sizeof(int))
        {
            t.Execute(command);
            cout<<endl;
        }
        else if (n == 0)
        {
            //相对应的写端关闭了
            cout<<"父进程让我退出，我就退出了"<<getpid()<<endl;
            break;
        }
    }
}

// 构建控制结构，父进程写入，子进程读取
void createProcesses(vector<EndPoint> &end_points)
{
    // 1.先进行构建控制结构：父进程进行写入，子进程读取
    for (int i = 0; i < gnum; i++)
    {
        // 1.1 创建管道
        int pipefd[2] = {0};
        int n = pipe(pipefd);
        assert(n == 0);
        (void )n; // 防止release版本将为使用的变量删除

        // 1.2 创建子进程
        pid_t id = fork();
        assert(id != -1);
        (void )id; // 防止release版本将为使用的变量删除

        if (id == 0)
        {
            // 子进程

            //将从父进程那继承来的其他进程的读端关闭
            cout<<getpid()<<" 子进程关闭了继承自父进程的其他子进程的写端：";
            for(const auto&ep:end_points)
            {
                cout<<ep._write_id<<" ";
                close(ep._write_id);
            }
            cout<<endl;

            // 关闭自己的写端
            close(pipefd[1]);

            // 1.3 通信

            // 子进程读取“指令”，都从标准输出中获取
            // 将管道的读重定向到标准输出中
            dup2(pipefd[0], 0);

            // 1.4 子进程开始等待命令。
            WaitCommand();

            // 关闭读端然后退出子进程
            close(pipefd[0]);
            exit(0);
        }

        // 到这的一定是父进程

        // 关闭读端
        close(pipefd[0]);

        // 将新创建的子进程的fd和管道的写的文件描述符存储起来
        end_points.push_back(EndPoint(id, pipefd[1]));
    }
}

int ShowBoard()
{
    cout<<endl;
    cout<<"#######################################"<<endl;
    cout<<"#######################################"<<endl;
    cout<<"# 0. 执行日志任务   1. 执行数据库任务 #"<<endl;
    cout<<"# 2. 执行请求任务   3. 退出           #"<<endl;
    cout<<"#######################################"<<endl;
    cout<<"#######################################"<<endl;
    cout<<"请选择# ";

    int command=0;
    std::cin>>command;

    return command;
}

void ctrlProcess(const vector<EndPoint>&end_points)
{
    // 父进程开始发布命令
    int cnt=0;
    while(true)
    {
        //1. 选择任务
        int command=ShowBoard();
        //为3就退出
        if(command==3)
        {
            break;
        }

        if(command<0&&command>2)
        {
            cout<<"输入有误，请重新输入"<<endl;
            continue;
        }

        //2. 按顺序给子进程派发任务
        int indix=cnt++;
        cnt%=end_points.size();

        cout<<"你选择了进程："<<end_points[indix].name()<<" | 处理"<<command<<"号任务"<<endl;

        //4. 下发任务
        write(end_points[indix]._write_id,&command,sizeof(command));
        
        sleep(1);
    }
}

//回收子进程
void waitProcess(vector<EndPoint>&end_points)
{
    //如果我们创建管道后，直接再创建子进程，那么子进程将继承父进程的所有文件描述符，
    //后创建的子进程会保留指向先创建的管道的读写文件描述符
    //所以顺序同时关闭子进程的写端和回收僵尸进程，其实并没有关闭子进程的写端，因为此时其引用计数仍>0

    // //这种写法会在waitpid时堵塞，因为子进程的写端还没有关闭
    // //所以子进程的读端处于堵塞状态，不会退出
    // for(const auto&ep:end_points)
    // {
    //     close(ep._write_id);
    //     cout<<"父进程关闭了"<<ep._child_id<<"的写端"<<endl;
    //     waitpid(ep._child_id,nullptr,0);
    //     cout<<"父进程回收了"<<ep._child_id<<endl;
    // }

    //解决方法一：倒着关闭写端，回收僵尸进程
    //解决方法二：在创建新的子进程后，子进程关闭从父进程那边继承的其他子进程的读写端


    //我们只需要让父进程关闭子进程的写端，子进程的读端会读到文件尾，然后自己就退了。

    // //1.关闭子进程的写端
    // for(const auto&ep:end_points)
    // {
    //     close(ep._write_id);
    // }

    // sleep(5);
    // cout<<"父进程让所有的子进程都退出"<<endl;
    
    // //2. 父进程回收子进程的僵尸状态
    // for(const auto&ep:end_points)
    // {
    //     waitpid(ep._child_id,nullptr,0);
    // }

    // cout<<"父进程回收了所有的子进程"<<endl;
    // sleep(5);

    // //倒着关闭子进程的写端，再回收子进程
    // for(int i=end_points.size()-1;i>=0;i--)
    // {
    //     close(end_points[i]._write_id);
    //     cout<<"父进程让"<<end_points[i]._child_id<<"子进程退出"<<endl;

    //     waitpid(end_points[i]._child_id,nullptr,0);
    //     cout<<"父进程回收了"<<end_points[i]._child_id<<"子进程"<<endl;
    //     cout<<endl;

    //     sleep(1);
    // }



    //一个一个退出
    for(const auto&ep:end_points)
    {
        close(ep._write_id);
        cout<<"父进程让"<<ep._child_id<<"子进程退出"<<endl;

        waitpid(ep._child_id,nullptr,0);
        cout<<"父进程回收了"<<ep._child_id<<"子进程"<<endl;
        cout<<endl;

        sleep(1);
    }

}

int main()
{
    // 用于存储子进程的pid和相对应管道的文件描述符
    vector<EndPoint> end_points;

    // 创建控制模块
    createProcesses(end_points);
    sleep(1);
    //开始通信
    ctrlProcess(end_points);

    //回收子进程
    waitProcess(end_points);

    cout<<"程序成功退出，欢迎下次使用"<<endl;

    return 0;
}